// #include <iostream>
// #include <type_traits>
// #include <vector>
// //#include <iterator>
// using namespace std;
// struct Base
// {
//     typedef int Type;

// };

// struct Derive:public Base
// {

// };
// int main()
// {
//    cout<<typeid(typename iterator_traits<vector<Base>::iterator>::value_type).name()<<endl;
//     typename iterator_traits<vector<int>::iterator>::reference xll=;
//     //vector<int>::value_type
//     //Derive::Type a;
//     //cout<<typeid(double).name()<<endl;
//     return 0;
// }
// #include <iostream>
// #include <iterator>
// #include <vector>
// #include <list>

// template<class BidirIt>
// void my_reverse(BidirIt first, BidirIt last)
// {
//     typename std::iterator_traits<BidirIt>::difference_type n = std::distance(first, last);
//     --n;
//     while(n > 0) {
//         typename std::iterator_traits<BidirIt>::value_type tmp = *first;
//         *first++ = *--last;
//         *last = tmp;
//         n -= 2;
//     }
// }

// int main()
// {
//     std::vector<int> v{1, 2, 3, 4, 5};
//     my_reverse(v.begin(), v.end());
//     for (int n : v) {
//         std::cout << n << ' ';
//     }
//     std::cout << '\n';

//     std::list<int> l{1, 2, 3, 4, 5};
//     my_reverse(l.begin(), l.end());
//     for (auto n : l) {
//         std::cout << n << ' ';
//     }
//     std::cout << '\n';

//     int a[] = {1, 2, 3, 4, 5};
//     my_reverse(a, a+5);
//     for (int i=0; i<5; ++i) {
//         std::cout << a[i] << ' ';
//     }
//     std::cout << '\n';

// //    std::istreambuf_iterator<char> i1(std::cin), i2;
// //    my_reverse(i1, i2); // 编译错误

// }

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
//#include <iterator_traits>
using namespace std;
namespace lnb
{

    struct input_iterator_tag
    {
    };

    struct output_iterator_tag
    {
    };

    struct forward_iterator_tag : public input_iterator_tag
    {
    };

    struct bidirectional_iterator_tag : public forward_iterator_tag
    {
    };

    struct randomiterator_tag : public bidirectional_iterator_tag
    {
    };

    template <class InputIterator, class Distance>
    inline void _advance(InputIterator &it, Distance n, input_iterator_tag)
    {
        while(n--)
        {
            it++;
        }
    }

    template<class ForwardIterator,class Distance>
    inline void _advance(ForwardIterator& it,Distance n,forward_iterator_tag)
    {
        _advance(it,n,input_iterator_tag());

    }


    template<class BidrectionalIterator,class Distance>
    inline void _advance(BidrectionalIterator& it,Distance n,bidirectional_iterator_tag)
    {
                if(n>=0)
        {
            while(n--)
            {
                it++;
            }
        }
        else
        {
            while(n++)
            {
                it--;
            }
        }
    }


    template<class RandomInterator,class Distance>
    inline void _advance(RandomInterator& it,Distance n,randomiterator_tag)
    {
        it+=n;
    }


    template<class InputInterator,class Distance>
    inline void advance (InputInterator& it,Distance n)
    {
        _advance(it,n,std::iterator_traits<InputInterator>::iterator_category(it));
    }
}


int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    std::vector<int> v(arr,arr+10);
    vector<int>::iterator it=v.begin();
    lnb::advance(it,5);
    while(it!=v.end())
    {
        cout<<*it<<endl;
    }


    return 0;
}